home *** CD-ROM | disk | FTP | other *** search
/ Aminet 43 / Aminet 43 (2001)(GTI - Schatztruhe)[!][Jun 2001].iso / Aminet / dev / moni / SystemViewer.lha / Source / SysScreens.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-25  |  45.6 KB  |  1,819 lines
  1. /****h *AmigaTalk/SysScreens.c ****************************************
  2. **
  3. ** NAME
  4. **    SysScreens.c - display info about all open screens & windows
  5. **
  6. ** DESCRIPTION
  7. **    Allow the user to view a list of all Screens & Windows that are
  8. **    currently open to Intuition.  The user can close any Window or
  9. **    Screen safely(?).
  10. **
  11. ** FUNCTIONAL INTERFACE:
  12. **
  13. **    PUBLIC void CloseTheScreen( struct Screen *scr );
  14. **
  15. **    PUBLIC void CloseTheWindow( struct Window *wind );
  16. **
  17. **    PUBLIC int HandleScreenLV( void );
  18. **
  19. ***********************************************************************
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <string.h>
  24.  
  25. #include <exec/types.h>
  26. #include <exec/lists.h>
  27. #include <exec/nodes.h>
  28.  
  29. #include <dos/dosextens.h>
  30.  
  31. #include <AmigaDOSErrs.h>
  32.  
  33. #include <intuition/intuitionbase.h>
  34. #include <intuition/classes.h>
  35. #include <intuition/classusr.h>
  36. #include <intuition/gadgetclass.h>
  37.  
  38. #include <libraries/gadtools.h>
  39.  
  40. #include <graphics/displayinfo.h>
  41. #include <graphics/gfxbase.h>
  42.  
  43. #include <clib/exec_protos.h>
  44. #include <clib/intuition_protos.h>
  45. #include <clib/gadtools_protos.h>
  46. #include <clib/graphics_protos.h>
  47. #include <clib/utility_protos.h>
  48. #include <clib/diskfont_protos.h>
  49.  
  50. #include "CPGM:GlobalObjects/CommonFuncs.h"
  51.  
  52. #include "SysLists.h"
  53.  
  54. #define MAX_HEIGHT 380
  55.  
  56. PRIVATE int HandleWindowInfo( void *structptr, int whichdisplay );
  57.  
  58. PRIVATE char ver[] = "$VER: SysScreens 1.0 (12/20/1999) by J.T. Steichen";
  59.  
  60. PRIVATE struct Window *IWnd = NULL;
  61.  
  62. PRIVATE UWORD ILeft   = 0;
  63. PRIVATE UWORD ITop    = 32;
  64. PRIVATE UWORD IWidth  = 640;
  65. PRIVATE UWORD IHeight = MAX_HEIGHT;
  66.  
  67. PRIVATE UBYTE *IWTitle = "System Screens & Windows Full Info:";
  68.  
  69. #define XPOS    6
  70. #define MAXNODE 100
  71.  
  72. PRIVATE struct Gadget *ScrGadgets[ SCR_CNT ];
  73.  
  74. PRIVATE UBYTE *WTitle = "System Screens & Windows Info:";
  75.  
  76. PRIVATE UWORD StrYPos[32] = { 0, };
  77.  
  78. PRIVATE struct MinList ScrList;
  79.  
  80. PRIVATE struct Node    ScrNode;
  81. PRIVATE struct Node    ScrNodes[ MAXNODE ]      = { NULL, };
  82.  
  83. PRIVATE UBYTE          NodeStrs[ MAXNODE * 80 ] = "";
  84.  
  85. PRIVATE UWORD ScrGTypes[] = {
  86.  
  87.    LISTVIEW_KIND, BUTTON_KIND, BUTTON_KIND, 
  88.    BUTTON_KIND,   BUTTON_KIND, TEXT_KIND
  89. };
  90.  
  91. PRIVATE int SLVClicked(    int itemnum );
  92. PRIVATE int UpdateClicked( int dummy   );
  93. PRIVATE int CancelClicked( int dummy   );
  94. PRIVATE int MoreClicked(   int dummy   );
  95. PRIVATE int CloseClicked(  int dummy   );
  96.  
  97. PRIVATE struct NewGadget ScrNGad[] = {
  98.  
  99.      2,   3, 627, 200,               NULL, NULL, ScrLV,
  100.    0,           NULL, (APTR) SLVClicked,
  101.  
  102.      4, 205,  71, 17, (UBYTE *) "_Update", NULL, ScrUpdate,
  103.    PLACETEXT_IN, NULL, (APTR) UpdateClicked,
  104.  
  105.     89, 205,  72, 17, (UBYTE *) "_More",   NULL, ScrMore,
  106.    PLACETEXT_IN, NULL, (APTR) MoreClicked,
  107.  
  108.    255, 205,  72, 17, (UBYTE *) "Close",   NULL, ScrClose,
  109.    PLACETEXT_IN, NULL, (APTR) CloseClicked,
  110.  
  111.    554, 205,  72, 17, (UBYTE *) "_Cancel", NULL, ScrCancel,
  112.    PLACETEXT_IN, NULL, (APTR) CancelClicked,
  113.  
  114.      5, 228, 620, 17,                NULL, NULL, ScrSelection, 
  115.    0, NULL, NULL
  116. };
  117.  
  118. PRIVATE ULONG ScrGTags[] = {
  119.  
  120.    GTLV_ShowSelected, NULL, (LAYOUTA_Spacing), 2, (TAG_DONE),
  121.  
  122.    (GT_Underscore), '_', (TAG_DONE),
  123.    (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  124.  
  125.    (GA_Disabled), TRUE, (TAG_DONE),
  126.  
  127.    (GT_Underscore), '_', (TAG_DONE),
  128.  
  129.    (GTTX_Border), TRUE, (TAG_DONE)
  130. };
  131.  
  132. // -----------------------------------------------------------------
  133.  
  134. PRIVATE void WriteText( char *string, int xpos, int ypos, int color ) 
  135. {
  136.    struct RastPort  *rp = IWnd->RPort;
  137.    struct IntuiText  outtxt;
  138.  
  139.    outtxt.FrontPen  = color;
  140.    outtxt.BackPen   = 0;
  141.    outtxt.DrawMode  = JAM1;
  142.    outtxt.LeftEdge  = 0;
  143.    outtxt.TopEdge   = 0;
  144.    outtxt.ITextFont = Font;
  145.    outtxt.NextText  = NULL;
  146.    outtxt.IText     = (UBYTE *) string;
  147.  
  148.    PrintIText( rp, &outtxt, xpos, ypos );
  149.  
  150.    return;
  151. }
  152.  
  153. PRIVATE char typ[10], *pgmtype = &typ[0];
  154.  
  155. PRIVATE char *GetTask_Process( UBYTE type )
  156. {
  157.    if (type == NT_TASK)
  158.       strcpy( pgmtype, "TASK" );
  159.    else if (type == NT_PROCESS)
  160.       strcpy( pgmtype, "PROCESS" );
  161.    else   
  162.       strcpy( pgmtype, "TASK" );
  163.  
  164.    return( pgmtype );
  165. }
  166.  
  167. PRIVATE BOOL CheckBit( int flags, int bit )
  168. {
  169.    if ((flags & bit) == bit)
  170.       return( TRUE );
  171.    else
  172.       return( FALSE );
  173. }
  174.  
  175. PRIVATE char ts[10], *taskstate = &ts[0];
  176. PRIVATE BOOL DispTaskFlag = TRUE;
  177.  
  178. PRIVATE char *GetTaskState( struct Task *t )
  179. {
  180.    if (t == NULL)
  181.       return( "INVALID" );
  182.  
  183.    switch (t->tc_State)
  184.       {
  185.       case TS_INVALID:
  186.          strcpy( taskstate, "INVALID" );  // Stack won't be right.
  187.          DispTaskFlag = FALSE;
  188.          break;
  189.          
  190.       case TS_ADDED:
  191.          strcpy( taskstate, "ADDED" );
  192.          DispTaskFlag = TRUE;
  193.          break;
  194.          
  195.       case TS_RUN:
  196.          strcpy( taskstate, "RUNNING" );
  197.          DispTaskFlag = TRUE;
  198.          break;
  199.          
  200.       case TS_READY:
  201.          strcpy( taskstate, "READY" );
  202.          DispTaskFlag = TRUE;
  203.          break;
  204.          
  205.       case TS_WAIT:
  206.          strcpy( taskstate, "WAITING" );
  207.          DispTaskFlag = TRUE;
  208.          break;
  209.          
  210.       case TS_EXCEPT:
  211.          strcpy( taskstate, "EXCEPTION" );
  212.          DispTaskFlag = TRUE;
  213.          break;
  214.          
  215.       case TS_REMOVED:
  216.          strcpy( taskstate, "REMOVED" );
  217.          DispTaskFlag = TRUE;
  218.          break;
  219.       }
  220.  
  221.    return( taskstate );
  222. }
  223.  
  224. PRIVATE void SetTaskFlags( struct Task *t, char *str )
  225. {
  226.    *str = '\0';
  227.  
  228.    if (CheckBit( t->tc_Flags, TF_PROCTIME ) == TRUE)
  229.       strcpy( str, "TF_PROCTIME " );
  230.    
  231.    if (CheckBit( t->tc_Flags, TF_ETASK ) == TRUE)
  232.       strcat( str, "TF_ETASK " );
  233.  
  234.    if (CheckBit( t->tc_Flags, TF_STACKCHK ) == TRUE)
  235.       strcat( str, "TF_STACKCHK " );
  236.  
  237.    if (CheckBit( t->tc_Flags, TF_EXCEPT ) == TRUE)
  238.       strcat( str, "TF_EXCEPT " );
  239.  
  240.    if (CheckBit( t->tc_Flags, TF_SWITCH ) == TRUE)
  241.       strcat( str, "TF_SWITCH " );
  242.  
  243.    if (CheckBit( t->tc_Flags, TF_LAUNCH ) == TRUE)
  244.       strcat( str, "TF_LAUNCH" );
  245.  
  246.    return;
  247. }
  248.  
  249.  
  250. #define B2APTR( bptr ) ((bptr) << 2)
  251.  
  252. PRIVATE void WriteTask( void *ptr )
  253. {
  254.    IMPORT UWORD StrYPos[];
  255.    
  256.    struct Task    *task    = (struct Task *) ptr;
  257.    struct Process *process = NULL;
  258.  
  259.    char t[82], *title = &t[0];
  260.    char s[82], *str   = &s[0];
  261.  
  262.    int  size = 0;
  263.    
  264.    if (task == NULL)
  265.       return; 
  266.  
  267.    sprintf( title, "%s: (%08LX) -> %-40.40s", 
  268.             GetTask_Process( task->tc_Node.ln_Type ),
  269.             task, task->tc_Node.ln_Name
  270.           );
  271.  
  272.    SetWindowTitles( Wnd, title, (char *) -1 );
  273.  
  274.    // Common (to Task & Process) data to display:
  275.    if ((task->tc_Node.ln_Type == NT_TASK) 
  276.        || (task->tc_Node.ln_Type == NT_PROCESS))
  277.       {
  278.       sprintf( str, "STATE: %s Priority: %4d", 
  279.                GetTaskState( task ),
  280.                task->tc_Node.ln_Pri 
  281.              );
  282.  
  283.       WriteText( str, XPOS, StrYPos[0], 2 );
  284.  
  285.       sprintf( str, "SigAlloc: %08LX SigWait : %08LX SigRecvd : %08LX SigExcept: %08LX", 
  286.                task->tc_SigAlloc, task->tc_SigWait, 
  287.                task->tc_SigRecvd, task->tc_SigExcept
  288.              );
  289.  
  290.       WriteText( str, XPOS, StrYPos[1], 1 );
  291.  
  292.       sprintf( str, "TrapData: %08LX TrapCode: %08LX TrapAlloc: %08LX TrapAble : %08LX",
  293.                task->tc_TrapData, task->tc_TrapCode, 
  294.                task->tc_TrapAlloc, task->tc_TrapAble
  295.              );
  296.  
  297.       WriteText( str, XPOS, StrYPos[2], 1 );
  298.  
  299.       sprintf( str, "Switch(): %08LX Launch(): %08LX UserData : %08LX", 
  300.                task->tc_Switch, task->tc_Launch, 
  301.                task->tc_UserData
  302.              );
  303.  
  304.       WriteText( str, XPOS, StrYPos[3], 2 );
  305.  
  306.       sprintf( str, "ExceptData: %08LX ExceptCode: %08LX", 
  307.                task->tc_ExceptData, task->tc_ExceptCode
  308.              );
  309.  
  310.       WriteText( str, XPOS, StrYPos[5], 1 );
  311.  
  312.       size = (int) task->tc_SPUpper - (int) task->tc_SPLower;
  313.  
  314.       sprintf( str, "SPReg     : %08LX SPUpper   : %08LX SPLower: %08LX size: %d",
  315.                task->tc_SPReg, task->tc_SPUpper, 
  316.                task->tc_SPLower, size
  317.              );
  318.  
  319.       WriteText( str, XPOS, StrYPos[6], 2 );
  320.  
  321.       sprintf( str, "IDNestCnt: %-08d TDNestCnt: %3d",
  322.                task->tc_IDNestCnt, task->tc_TDNestCnt
  323.              );
  324.  
  325.       WriteText( str, XPOS, StrYPos[8], 1 );
  326.  
  327.       sprintf( str, "MemEntry : %08LX", task->tc_MemEntry.lh_Head );
  328.  
  329.       WriteText( str, XPOS, StrYPos[9], 1 );
  330.  
  331.       WriteText( "Flags:", XPOS, StrYPos[10], 3 );
  332.  
  333.       SetTaskFlags( task, str );
  334.  
  335.       WriteText( str, XPOS, StrYPos[11], 1 );
  336.  
  337.       if (task->tc_Node.ln_Type == NT_TASK) 
  338.          WriteText( "Press Close Gadget when you're done!", 
  339.                     150, StrYPos[12], 2 
  340.                   ); 
  341.       }
  342.  
  343.    // Process additions to display:
  344.    if (task->tc_Node.ln_Type == NT_PROCESS)
  345.       {
  346.       char   pn[256], *path = &pn[0];
  347.       UBYTE *ttl = NULL;
  348.             
  349.       process = (struct Process *) ptr;
  350.  
  351.       WriteText( "Process Structure:", XPOS, StrYPos[12], 3 );  
  352.  
  353.       if ((struct Window *) process->pr_WindowPtr != NULL)
  354.          ttl = ((struct Window *) process->pr_WindowPtr)->Title;
  355.       else
  356.          ttl = "*NO TITLE!*";
  357.  
  358.       sprintf( str, "WindowPtr  : %08LX Title: %-40.40s", 
  359.                process->pr_WindowPtr, 
  360.                (strlen( ttl ) > 0) ? ttl : (UBYTE *) "*NO TITLE!*"
  361.              );
  362.  
  363.       WriteText( str, XPOS, StrYPos[13], 2 );
  364.  
  365.       if (process->pr_CurrentDir != NULL)
  366.          (void) NameFromLock( process->pr_CurrentDir, path, 255 );
  367.           
  368.       sprintf( str, "CurrentDir : %08LX Path : %-40.40s", 
  369.                B2APTR( process->pr_CurrentDir ),
  370.                (path == NULL) ? "*NO PATH*" : path
  371.              );
  372.  
  373.       WriteText( str, XPOS, StrYPos[14], 2 );
  374.  
  375.       sprintf( str, "MsgPort    : %08LX SegList       : %08LX", 
  376.                process->pr_MsgPort, B2APTR( process->pr_SegList )
  377.              );
  378.  
  379.       WriteText( str, XPOS, StrYPos[15], 1 );
  380.  
  381.       sprintf( str, "StackBase  : %08LX StackSize     : %d", 
  382.                B2APTR( process->pr_StackBase ), process->pr_StackSize
  383.              );
  384.  
  385.       WriteText( str, XPOS, StrYPos[16], 1 );
  386.  
  387.       sprintf( str, "CIS        : %08LX COS           : %08LX", 
  388.                B2APTR( process->pr_CIS ), B2APTR( process->pr_COS )
  389.              );
  390.  
  391.       WriteText( str, XPOS, StrYPos[17], 1 );
  392.  
  393.       sprintf( str, "ConsoleTask: %08LX FileSystemTask: %08LX", 
  394.                process->pr_ConsoleTask, 
  395.                process->pr_FileSystemTask
  396.              );
  397.  
  398.       WriteText( str, XPOS, StrYPos[18], 1 );
  399.  
  400.       sprintf( str, "PktWait    : %08LX ReturnAddr    : %08LX", 
  401.                process->pr_PktWait, 
  402.                process->pr_ReturnAddr
  403.              );
  404.  
  405.       WriteText( str, XPOS, StrYPos[19], 1 );
  406.  
  407.       sprintf( str, "Arguments -> %-60.60s", 
  408.                (process->pr_Arguments == NULL) ? (UBYTE *) "*NO ARGS!*" 
  409.                                                : process->pr_Arguments
  410.              );
  411.  
  412.       WriteText( str, XPOS, StrYPos[20], 2 );
  413.  
  414.       sprintf( str, "GlobVec    : %08LX CLI           : %08LX", 
  415.                process->pr_GlobVec, 
  416.                B2APTR( process->pr_CLI )
  417.              );
  418.  
  419.       WriteText( str, XPOS, StrYPos[21], 1 );
  420.  
  421.       // CLI additional information: 
  422.  
  423.       if (process->pr_CLI != NULL)
  424.          {
  425.          struct CommandLineInterface *cli = NULL;
  426.          BOOL                         iflag = FALSE, bflag = FALSE;
  427.  
  428.          cli = (struct CommandLineInterface *) (process->pr_CLI << 2);
  429.  
  430.          WriteText( "CommandLineInterface structure:", 
  431.                     XPOS, StrYPos[22], 3
  432.                   );
  433.  
  434.          sprintf( str, "CommandDir   : %08LX", 
  435.                   B2APTR( cli->cli_CommandDir )
  436.                 );
  437.  
  438.          WriteText( str, XPOS, StrYPos[23], 1 );
  439.  
  440.          sprintf( str, "StandardInput: %08LX StandardOutput: %08LX", 
  441.                   B2APTR( cli->cli_StandardInput ),
  442.                   B2APTR( cli->cli_StandardOutput )
  443.                 );
  444.  
  445.          WriteText( str, XPOS, StrYPos[24], 1 );
  446.  
  447.          sprintf( str, "CurrentInput : %08LX CurrentOutput : %08LX", 
  448.                   B2APTR( cli->cli_CurrentInput  ),
  449.                   B2APTR( cli->cli_CurrentOutput )
  450.                 );
  451.  
  452.          WriteText( str, XPOS, StrYPos[25], 1 );
  453.  
  454.          if (cli->cli_Interactive != FALSE)
  455.             iflag = TRUE;
  456.             
  457.          if (cli->cli_Background != FALSE)
  458.             bflag = TRUE;
  459.             
  460.          sprintf( str, "Module       : %08LX %s %s", 
  461.                   B2APTR( cli->cli_Module ),
  462.                   (bflag == TRUE) ? "BACKGROUND" : "",
  463.                   (iflag == TRUE) ? "& INTERACTIVE" : ""
  464.                 );
  465.  
  466.          WriteText( str, XPOS, StrYPos[26], 1 );
  467.          }
  468.  
  469.       WriteText( "Press Close Gadget when you're done!", 
  470.                  150, StrYPos[27], 2 
  471.                ); 
  472.       }
  473.  
  474.    return;
  475. }
  476.  
  477.  
  478. PRIVATE void CountGadgets( struct Window *w, int *bgad, 
  479.                            int *sgad, int *pgad
  480.                          )
  481. {
  482.    struct Gadget *first = w->FirstGadget;
  483.    
  484.    while (first != NULL)
  485.       {
  486.       switch (first->GadgetType & 0x07)
  487.          {
  488.          case BOOLGADGET:
  489.             *bgad += 1;
  490.             break; 
  491.  
  492.          case STRGADGET:
  493.             *sgad += 1;
  494.             break; 
  495.  
  496.          case PROPGADGET:
  497.             *pgad += 1;
  498.             break; 
  499.          }
  500.           
  501.       first = first->NextGadget;
  502.       }
  503.  
  504.    return;
  505. }
  506.  
  507. PRIVATE void CountMenus( struct Window *w, int *m, int *mi )
  508. {
  509.    struct Menu     *menu  = w->MenuStrip;
  510.    struct MenuItem *mitem = NULL;
  511.  
  512.    while (menu != NULL)
  513.       {
  514.       *m += 1;
  515.       mitem = menu->FirstItem;
  516.       
  517.       while (mitem != NULL)
  518.          {
  519.          *mi += 1;
  520.          
  521.          if (mitem->SubItem != NULL)
  522.             {
  523.             struct MenuItem *subs = mitem->SubItem;
  524.             
  525.             while (subs != NULL)
  526.                {
  527.                *mi += 1;
  528.                
  529.                subs = subs->NextItem;
  530.                }
  531.             }
  532.  
  533.          mitem = mitem->NextItem;
  534.          }
  535.       
  536.       menu = menu->NextMenu;
  537.       }
  538.  
  539.    return;
  540. }
  541.  
  542. PRIVATE void SetScreenFlagString( char *str, struct Screen *s )
  543. {
  544.    if (CheckBit( s->Flags, CUSTOMSCREEN ) == TRUE)
  545.       strcpy( str, "CUSTOMSCREEN  " );
  546.    else
  547.       strcpy( str, "WBENCHSCREEN  " );
  548.  
  549.    if (CheckBit( s->Flags, SHOWTITLE ) == TRUE)
  550.       strcat( str, "SHOWTITLE  " );
  551.  
  552.    if (CheckBit( s->Flags, BEEPING ) == TRUE)
  553.       strcat( str, "BEEPING  " );
  554.  
  555.    if (CheckBit( s->Flags, CUSTOMBITMAP ) == TRUE)
  556.       strcat( str, "CUSTOMBITMAP" );
  557.  
  558.    return;
  559. }
  560.  
  561.  
  562. PRIVATE void SetScreenViewMode1( char *str, struct Screen *s )
  563. {
  564.    *str = '\0';
  565.  
  566.    if (CheckBit( s->ViewPort.Modes, HIRES ) == TRUE)
  567.       strcpy( str, "HIRES  " );
  568.  
  569.    if (CheckBit( s->ViewPort.Modes, SPRITES ) == TRUE)
  570.       strcat( str, "SPRITES  " );
  571.  
  572.    if (CheckBit( s->ViewPort.Modes, VP_HIDE ) == TRUE)
  573.       strcat( str, "VP_HIDE  " );
  574.  
  575.    if (CheckBit( s->ViewPort.Modes, EXTENDED_MODE ) == TRUE)
  576.       strcat( str, "EXTENDED  " );
  577.  
  578.    if (CheckBit( s->ViewPort.Modes, HAM ) == TRUE)
  579.       strcat( str, "HAM  " );
  580.  
  581.    if (CheckBit( s->ViewPort.Modes, DUALPF ) == TRUE)
  582.       strcat( str, "DUALPF  " );
  583.  
  584.    if (CheckBit( s->ViewPort.Modes, GENLOCK_AUDIO ) == TRUE)
  585.       strcat( str, "GENLOCK_AUDIO  " );
  586.  
  587.    if (CheckBit( s->ViewPort.Modes, PFBA ) == TRUE)
  588.       strcat( str, "PFBA" );
  589.  
  590.    return;
  591. }
  592.  
  593. PRIVATE void SetScreenViewMode2( char *str, struct Screen *s )
  594. {
  595.    *str = '\0';
  596.    
  597.    if (CheckBit( s->ViewPort.Modes, LACE ) == TRUE)
  598.       strcpy( str, "LACE  " );
  599.  
  600.    if (CheckBit( s->ViewPort.Modes, DOUBLESCAN ) == TRUE)
  601.       strcat( str, "DOUBLESCAN  " );
  602.  
  603.    if (CheckBit( s->ViewPort.Modes, SUPERHIRES ) == TRUE)
  604.       strcat( str, "SUPERHIRES  " );
  605.  
  606.    if (CheckBit( s->ViewPort.Modes, EXTRA_HALFBRITE ) == TRUE)
  607.       strcat( str, "EXTRA_HALFBRITE  " );
  608.  
  609.    if (CheckBit( s->ViewPort.Modes, GENLOCK_VIDEO ) == TRUE)
  610.       strcat( str, "GENLOCK_VIDEO" );
  611.  
  612.    return;
  613. }
  614.  
  615. PRIVATE void SetWindowFlags1( struct Window *w, char *str )
  616. {
  617.    *str = '\0';
  618.  
  619.    if (CheckBit( w->Flags, WFLG_SIZEGADGET ) == TRUE)
  620.       strcpy( str, "WFLG_SIZEGADGET " );
  621.  
  622.    if (CheckBit( w->Flags, WFLG_DRAGBAR ) == TRUE)
  623.       strcat( str, "WFLG_DRAGBAR " );
  624.  
  625.    if (CheckBit( w->Flags, WFLG_DEPTHGADGET ) == TRUE)
  626.       strcat( str, "WFLG_DEPTHGADGET " );
  627.  
  628.    if (CheckBit( w->Flags, WFLG_CLOSEGADGET ) == TRUE)
  629.       strcat( str, "WFLG_CLOSEGADGET" );
  630.  
  631.    return;
  632. }
  633.  
  634. PRIVATE void SetWindowFlags2( struct Window *w, char *str )
  635. {
  636.    *str = '\0';
  637.  
  638.    if (CheckBit( w->Flags, WFLG_SMART_REFRESH ) == TRUE)
  639.       strcpy( str, "WFLG_SMART_REFRESH " );
  640.  
  641.    if (CheckBit( w->Flags, WFLG_SIMPLE_REFRESH ) == TRUE)
  642.       strcat( str, "WFLG_SIMPLE_REFRESH " );
  643.  
  644.    if (CheckBit( w->Flags, WFLG_SUPER_BITMAP ) == TRUE)
  645.       strcat( str, "WFLG_SUPER_BITMAP " );
  646.  
  647.    if (CheckBit( w->Flags, WFLG_OTHER_REFRESH ) == TRUE)
  648.       strcat( str, "WFLG_OTHER_REFRESH " );
  649.  
  650.    if (CheckBit( w->Flags, WFLG_GIMMEZEROZERO ) == TRUE)
  651.       strcat( str, "WFLG_GIMMEZEROZERO" );
  652.  
  653.    return;
  654. }
  655.  
  656. PRIVATE void SetWindowFlags3( struct Window *w, char *str )
  657. {
  658.    *str = '\0';
  659.  
  660.    if (CheckBit( w->Flags, WFLG_BACKDROP ) == TRUE)
  661.       strcpy( str, "WFLG_BACKDROP " );
  662.  
  663.    if (CheckBit( w->Flags, WFLG_REPORTMOUSE ) == TRUE)
  664.       strcat( str, "WFLG_REPORTMOUSE " );
  665.  
  666.    if (CheckBit( w->Flags, WFLG_BORDERLESS ) == TRUE)
  667.       strcat( str, "WFLG_BORDERLESS " );
  668.  
  669.    if (CheckBit( w->Flags, WFLG_ACTIVATE ) == TRUE)
  670.       strcat( str, "WFLG_ACTIVATE " );
  671.  
  672.    if (CheckBit( w->Flags, WFLG_SIZEBRIGHT ) == TRUE)
  673.       strcat( str, "WFLG_SIZEBRIGHT" );
  674.  
  675.    if (CheckBit( w->Flags, WFLG_SIZEBBOTTOM ) == TRUE)
  676.       strcat( str, "WFLG_SIZEBBOTTOM" );
  677.  
  678.    return;
  679. }
  680.  
  681. PRIVATE void SetWindowFlags4( struct Window *w, char *str )
  682. {
  683.    *str = '\0';
  684.  
  685.    if (CheckBit( w->Flags, WFLG_RMBTRAP ) == TRUE)
  686.       strcpy( str, "WFLG_RMBTRAP " );
  687.  
  688.    if (CheckBit( w->Flags, WFLG_NOCAREREFRESH ) == TRUE)
  689.       strcat( str, "WFLG_NOCAREREFRESH " );
  690.  
  691.    if (CheckBit( w->Flags, WFLG_WINDOWACTIVE ) == TRUE)
  692.       strcat( str, "WFLG_WINDOWACTIVE " );
  693.  
  694.    if (CheckBit( w->Flags, WFLG_WBENCHWINDOW ) == TRUE)
  695.       strcat( str, "WFLG_WBENCHWINDOW " );
  696.  
  697.    if (CheckBit( w->Flags, WFLG_HASZOOM ) == TRUE)
  698.       strcat( str, "WFLG_HASZOOM " );
  699.  
  700.    if (CheckBit( w->Flags, WFLG_ZOOMED ) == TRUE)
  701.       strcat( str, "WFLG_ZOOMED" );
  702.  
  703.    return;
  704. }
  705.  
  706. PRIVATE void SetIDCMPFlags1( struct Window *w, char *str )
  707. {
  708.    *str = '\0';
  709.  
  710.    if (CheckBit( w->IDCMPFlags, IDCMP_SIZEVERIFY ) == TRUE)
  711.       strcpy( str, "IDCMP_SIZEVERIFY " );
  712.  
  713.    if (CheckBit( w->IDCMPFlags, IDCMP_NEWSIZE ) == TRUE)
  714.       strcat( str, "IDCMP_NEWSIZE " );
  715.  
  716.    if (CheckBit( w->IDCMPFlags, IDCMP_REFRESHWINDOW ) == TRUE)
  717.       strcat( str, "IDCMP_REFRESHWINDOW " );
  718.  
  719.    if (CheckBit( w->IDCMPFlags, IDCMP_MOUSEBUTTONS ) == TRUE)
  720.       strcat( str, "IDCMP_MOUSEBUTTONS" );
  721.  
  722.    return;
  723. }
  724.  
  725. PRIVATE void SetIDCMPFlags2( struct Window *w, char *str )
  726. {
  727.    *str = '\0';
  728.  
  729.    if (CheckBit( w->IDCMPFlags, IDCMP_MOUSEMOVE ) == TRUE)
  730.       strcpy( str, "IDCMP_MOUSEMOVE " );
  731.  
  732.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETDOWN ) == TRUE)
  733.       strcat( str, "IDCMP_GADGETDOWN " );
  734.  
  735.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETUP ) == TRUE)
  736.       strcat( str, "IDCMP_GADGETUP " );
  737.  
  738.    if (CheckBit( w->IDCMPFlags, IDCMP_REQSET ) == TRUE)
  739.       strcat( str, "IDCMP_REQSET" );
  740.  
  741.    return;
  742. }
  743.  
  744. PRIVATE void SetIDCMPFlags3( struct Window *w, char *str )
  745. {
  746.    *str = '\0';
  747.  
  748.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUPICK ) == TRUE)
  749.       strcpy( str, "IDCMP_MENUPICK " );
  750.  
  751.    if (CheckBit( w->IDCMPFlags, IDCMP_CLOSEWINDOW ) == TRUE)
  752.       strcat( str, "IDCMP_CLOSEWINDOW " );
  753.  
  754.    if (CheckBit( w->IDCMPFlags, IDCMP_RAWKEY ) == TRUE)
  755.       strcat( str, "IDCMP_RAWKEY " );
  756.  
  757.    if (CheckBit( w->IDCMPFlags, IDCMP_REQVERIFY ) == TRUE)
  758.       strcat( str, "IDCMP_REQVERIFY" );
  759.  
  760.    return;
  761. }
  762.  
  763. PRIVATE void SetIDCMPFlags4( struct Window *w, char *str )
  764. {
  765.    *str = '\0';
  766.  
  767.    if (CheckBit( w->IDCMPFlags, IDCMP_REQCLEAR ) == TRUE)
  768.       strcpy( str, "IDCMP_REQCLEAR " );
  769.  
  770.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUVERIFY ) == TRUE)
  771.       strcat( str, "IDCMP_MENUVERIFY " );
  772.  
  773.    if (CheckBit( w->IDCMPFlags, IDCMP_NEWPREFS ) == TRUE)
  774.       strcat( str, "IDCMP_NEWPREFS " );
  775.  
  776.    if (CheckBit( w->IDCMPFlags, IDCMP_DISKINSERTED ) == TRUE)
  777.       strcat( str, "IDCMP_DISKINSERTED" );
  778.  
  779.    return;
  780. }
  781.  
  782. PRIVATE void SetIDCMPFlags5( struct Window *w, char *str )
  783. {
  784.    *str = '\0';
  785.  
  786.    if (CheckBit( w->IDCMPFlags, IDCMP_DISKREMOVED ) == TRUE)
  787.       strcpy( str, "IDCMP_DISKREMOVED " );
  788.  
  789.    if (CheckBit( w->IDCMPFlags, IDCMP_WBENCHMESSAGE ) == TRUE)
  790.       strcat( str, "IDCMP_WBENCHMESSAGE " );
  791.  
  792.    if (CheckBit( w->IDCMPFlags, IDCMP_ACTIVEWINDOW ) == TRUE)
  793.       strcat( str, "IDCMP_ACTIVEWINDOW " );
  794.  
  795.    if (CheckBit( w->IDCMPFlags, IDCMP_INACTIVEWINDOW ) == TRUE)
  796.       strcat( str, "IDCMP_INACTIVEWINDOW" );
  797.  
  798.    return;
  799. }
  800.  
  801. PRIVATE void SetIDCMPFlags6( struct Window *w, char *str )
  802. {
  803.    *str = '\0';
  804.  
  805.    if (CheckBit( w->IDCMPFlags, IDCMP_DELTAMOVE ) == TRUE)
  806.       strcpy( str, "IDCMP_DELTAMOVE " );
  807.  
  808.    if (CheckBit( w->IDCMPFlags, IDCMP_VANILLAKEY ) == TRUE)
  809.       strcat( str, "IDCMP_VANILLAKEY " );
  810.  
  811.    if (CheckBit( w->IDCMPFlags, IDCMP_INTUITICKS ) == TRUE)
  812.       strcat( str, "IDCMP_INTUITICKS " );
  813.  
  814.    if (CheckBit( w->IDCMPFlags, IDCMP_IDCMPUPDATE ) == TRUE)
  815.       strcat( str, "IDCMP_IDCMPUPDATE" );
  816.  
  817.    return;
  818. }
  819.  
  820. PRIVATE void SetIDCMPFlags7( struct Window *w, char *str )
  821. {
  822.    *str = '\0';
  823.  
  824.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUHELP ) == TRUE)
  825.       strcpy( str, "IDCMP_MENUHELP " );
  826.  
  827.    if (CheckBit( w->IDCMPFlags, IDCMP_CHANGEWINDOW ) == TRUE)
  828.       strcat( str, "IDCMP_CHANGEWINDOW " );
  829.  
  830.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETHELP ) == TRUE)
  831.       strcat( str, "IDCMP_GADGETHELP" );
  832.  
  833.    return;
  834. }
  835.  
  836.  
  837. PRIVATE char bf[82], *itxt  = &bf[0];
  838. PRIVATE char tx[82], *title = &tx[0];
  839.  
  840. PRIVATE void DisplayStructure( void *ptr, int struct_type )
  841. {
  842.    struct Screen *s = NULL;
  843.    struct Window *w = NULL;
  844.    struct Task   *t = NULL;
  845.   
  846.    int            bgad, sgad, pgad, m, mi;
  847.   
  848.    bgad = sgad = pgad = m = mi = 0;
  849.    
  850.    switch (struct_type)
  851.       {
  852.       case 0: // Screen data:
  853.          s = (struct Screen *) ptr;
  854.  
  855.          sprintf( title, "SCREEN: (%08LX) %s", s, s->Title );
  856.          SetWindowTitles( IWnd, title, (UBYTE *) -1 );
  857.  
  858.          sprintf( itxt, "DefaultTitle: %s", s->DefaultTitle );
  859.          WriteText( itxt, XPOS, StrYPos[0], 2 ); 
  860.  
  861.          sprintf( itxt, "Left     : %3u Top       : %3u Width: %4u Height: %4u", 
  862.                   s->LeftEdge, s->TopEdge, s->Width, s->Height 
  863.                 );
  864.          WriteText( itxt, XPOS, StrYPos[1], 1 ); 
  865.  
  866.          sprintf( itxt, "WBorLeft : %3u WBorTop   : %3u", 
  867.                   s->WBorLeft, s->WBorTop
  868.                 );
  869.          WriteText( itxt, XPOS, StrYPos[2], 1 ); 
  870.  
  871.          sprintf( itxt, "WBorRight: %3u WBorBottom: %3u", 
  872.                   s->WBorRight, s->WBorBottom
  873.                 );
  874.          WriteText( itxt, XPOS, StrYPos[3], 1 ); 
  875.  
  876.          sprintf( itxt, "DetailPen: %3u BlockPen  : %3u", 
  877.                   s->DetailPen, s->BlockPen
  878.                 );
  879.          WriteText( itxt, XPOS, StrYPos[4], 1 ); 
  880.  
  881.          sprintf( itxt, "ViewPort  : %08LX RastPort   : %08LX", 
  882.                   s->ViewPort, s->RastPort
  883.                 );
  884.          WriteText( itxt, XPOS, StrYPos[5], 1 ); 
  885.  
  886.          sprintf( itxt, "BitMap    : %08LX LayerInfo  : %08LX", 
  887.                   s->BitMap, s->LayerInfo
  888.                 );
  889.          WriteText( itxt, XPOS, StrYPos[6], 1 ); 
  890.  
  891.          sprintf( itxt, "ExtData   : %08LX UserData   : %08LX", 
  892.                   s->ExtData, s->UserData
  893.                 );
  894.          WriteText( itxt, XPOS, StrYPos[7], 1 ); 
  895.  
  896.          sprintf( itxt, "NextScreen: %08LX FirstWindow: %08LX", 
  897.                   s->NextScreen, s->FirstWindow
  898.                 );
  899.          WriteText( itxt, XPOS, StrYPos[8], 2 ); 
  900.  
  901.          sprintf( itxt, "BarHeight  : %3u BarVBorder : %3u BarHBorder: %3u", 
  902.                   s->BarHeight, s->BarVBorder, s->BarHBorder
  903.                 );
  904.          WriteText( itxt, XPOS, StrYPos[9], 1 ); 
  905.  
  906.          sprintf( itxt, "MenuVBorder: %3u MenuHBorder: %3u", 
  907.                   s->MenuVBorder, s->MenuHBorder
  908.                 );
  909.          WriteText( itxt, XPOS, StrYPos[10], 1 ); 
  910.  
  911.          WriteText( "Flags:", XPOS, StrYPos[11], 3 );
  912.          
  913.          SetScreenFlagString( itxt, s );
  914.          WriteText( itxt, XPOS, StrYPos[12], 1 );
  915.  
  916.          WriteText( "ViewModes:", XPOS, StrYPos[13], 3 );
  917.  
  918.          SetScreenViewMode1( itxt, s );
  919.          WriteText( itxt, XPOS, StrYPos[14], 1 );
  920.  
  921.          SetScreenViewMode2( itxt, s );
  922.          WriteText( itxt, XPOS, StrYPos[15], 1 );
  923.  
  924.          WriteText( "Press Close Gadget when you're done!", 
  925.                     150, StrYPos[16], 2 
  926.                   ); 
  927.          break;
  928.  
  929.       case 1: // Window data:
  930.          w = (struct Window *) ptr;
  931.  
  932.          sprintf( title, "WINDOW: (%08LX) %s", w, w->Title );
  933.          SetWindowTitles( IWnd, title, (UBYTE *) -1 );
  934.  
  935.          sprintf( itxt, "WScreen: %08LX -> %s", 
  936.                   w->WScreen, w->WScreen->Title 
  937.                 );
  938.          WriteText( itxt, XPOS, StrYPos[0], 2 ); 
  939.  
  940.          sprintf( itxt, "Left    : %3u Top      : %3u Width    : %5u Height   : %5u",
  941.                   w->LeftEdge, w->TopEdge, w->Width, w->Height 
  942.                 );
  943.          WriteText( itxt, XPOS, StrYPos[1], 1 ); 
  944.  
  945.          sprintf( itxt, "MinWidth: %3u MinHeight: %3u MaxWidth : %5u MaxHeight: %5u",
  946.                   w->MinWidth, w->MinHeight, w->MaxWidth, w->MaxHeight 
  947.                 );
  948.          WriteText( itxt, XPOS, StrYPos[2], 1 ); 
  949.  
  950.          sprintf( itxt, "BdrLeft : %3u BdrTop   : %3u BdrRight : %5u BdrBottom: %5u",
  951.                   w->BorderLeft, w->BorderTop, 
  952.                   w->BorderRight, w->BorderBottom
  953.                 );
  954.          WriteText( itxt, XPOS, StrYPos[3], 1 ); 
  955.  
  956.          sprintf( itxt, "XOffset : %3u YOffset  : %3u DetailPen: %5u BlockPen : %5u",
  957.                   w->XOffset, w->YOffset, w->DetailPen, w->BlockPen
  958.                 );
  959.          WriteText( itxt, XPOS, StrYPos[4], 1 ); 
  960.  
  961.          sprintf( itxt, "CheckMark: %08LX ExtData: %08LX UserData: %08LX",
  962.                   w->CheckMark, w->ExtData, w->UserData
  963.                 );
  964.          WriteText( itxt, XPOS, StrYPos[5], 2 ); 
  965.  
  966.          CountGadgets( w, &bgad, &sgad, &pgad );
  967.  
  968.          sprintf( itxt, "BoolGadgets: %2u StrGadgets: %4u PropGadgets: %2u",
  969.                   bgad, sgad, pgad
  970.                 );
  971.          WriteText( itxt, XPOS, StrYPos[6], 1 ); 
  972.  
  973.          CountMenus( w, &m, &mi );
  974.  
  975.          sprintf( itxt, "Menus      : %2u MenuItems : %4u", m, mi );
  976.          WriteText( itxt, XPOS, StrYPos[7], 1 ); 
  977.  
  978.          t = (struct Task *) w->UserPort->mp_SigTask;
  979.  
  980.          sprintf( itxt, "UserPort  : %08LX -> mp_SigTask: %08LX, %-30.30s",
  981.                   w->UserPort, w->UserPort->mp_SigTask,
  982.                   (t == NULL ? " " : t->tc_Node.ln_Name)
  983.                 );
  984.          WriteText( itxt, XPOS, StrYPos[8], 2 ); 
  985.  
  986.          t = (struct Task *) w->WindowPort->mp_SigTask;
  987.          
  988.          sprintf( itxt, "WindowPort: %08LX -> mp_SigTask: %08LX, %-30.30s",
  989.                   w->WindowPort, w->WindowPort->mp_SigTask,
  990.                   (t == NULL ? " " : t->tc_Node.ln_Name) 
  991.                 );
  992.          WriteText( itxt, XPOS, StrYPos[9], 2 ); 
  993.  
  994.          sprintf( itxt, "PtrHeight: %3u PtrWidth: %2u Pointer: %08LX",
  995.                   w->PtrHeight, w->PtrWidth, w->Pointer
  996.                 );
  997.          WriteText( itxt, XPOS, StrYPos[10], 1 ); 
  998.  
  999.          sprintf( itxt, "ReqCount : %3u NextWindow: %08LX",
  1000.                   w->ReqCount, w->NextWindow
  1001.                 );
  1002.          WriteText( itxt, XPOS, StrYPos[11], 1 ); 
  1003.  
  1004.          WriteText( "Flags:", XPOS, StrYPos[12], 3 );
  1005.  
  1006.          SetWindowFlags1( w, itxt );
  1007.          WriteText( itxt, XPOS, StrYPos[13], 1 ); 
  1008.  
  1009.          SetWindowFlags2( w, itxt );
  1010.          WriteText( itxt, XPOS, StrYPos[14], 1 ); 
  1011.  
  1012.          SetWindowFlags3( w, itxt );
  1013.          WriteText( itxt, XPOS, StrYPos[15], 1 ); 
  1014.  
  1015.          SetWindowFlags4( w, itxt );
  1016.          WriteText( itxt, XPOS, StrYPos[16], 1 ); 
  1017.  
  1018.          WriteText( "IDCMPFlags:", XPOS, StrYPos[17], 3 );
  1019.  
  1020.          SetIDCMPFlags1( w, itxt );
  1021.          WriteText( itxt, XPOS, StrYPos[18], 1 ); 
  1022.  
  1023.          SetIDCMPFlags2( w, itxt );
  1024.          WriteText( itxt, XPOS, StrYPos[19], 1 ); 
  1025.  
  1026.          SetIDCMPFlags3( w, itxt );
  1027.          WriteText( itxt, XPOS, StrYPos[20], 1 ); 
  1028.  
  1029.          SetIDCMPFlags4( w, itxt );
  1030.          WriteText( itxt, XPOS, StrYPos[21], 1 ); 
  1031.  
  1032.          SetIDCMPFlags5( w, itxt );
  1033.          WriteText( itxt, XPOS, StrYPos[22], 1 ); 
  1034.  
  1035.          SetIDCMPFlags6( w, itxt );
  1036.          WriteText( itxt, XPOS, StrYPos[23], 1 ); 
  1037.  
  1038.          SetIDCMPFlags7( w, itxt );
  1039.          WriteText( itxt, XPOS, StrYPos[24], 1 ); 
  1040.  
  1041.          WriteText( "Press Close Gadget when you're done!", 
  1042.                     150, StrYPos[25], 2 
  1043.                   ); 
  1044.          break;
  1045.       
  1046.       case 2: // Task structure:
  1047.          WriteTask( ptr );
  1048.          break;
  1049.  
  1050.       case 3: // Process structure:
  1051.          WriteTask( ptr );
  1052.          break;
  1053.       }
  1054.  
  1055.    return;
  1056. }
  1057.  
  1058.  
  1059. PRIVATE int OpenIWindow( int numlines )
  1060. {
  1061.    UWORD wleft = ILeft, wtop = ITop, ww, wh;
  1062.    int   i;
  1063.    
  1064.    ComputeFont( Scr, Font, &CFont, IWidth, IHeight );
  1065.  
  1066.    IHeight = (numlines + 1) * (CFont.FontY + 3) + 2;
  1067.  
  1068.    if (IHeight > MAX_HEIGHT)
  1069.       IHeight = MAX_HEIGHT;
  1070.  
  1071.    for (i = 0; i < 32; i++)
  1072.       StrYPos[i] = 16 + i * (CFont.FontY + 3);
  1073.          
  1074.    ww = ComputeX( CFont.FontX, IWidth  );
  1075.    wh = ComputeY( CFont.FontY, IHeight );
  1076.  
  1077.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width) 
  1078.       wleft = Scr->Width - ww;
  1079.  
  1080.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height) 
  1081.       wtop = Scr->Height - wh;
  1082.  
  1083.    if ( !(IWnd = OpenWindowTags( NULL,
  1084.  
  1085.                    WA_Left,        wleft,
  1086.                    WA_Top,         wtop,
  1087.                    WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  1088.                    WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  1089.                    WA_IDCMP,       BUTTONIDCMP | IDCMP_GADGETUP
  1090.                      | IDCMP_REFRESHWINDOW | IDCMP_CLOSEWINDOW,
  1091.  
  1092.                    WA_Flags,       WFLG_SMART_REFRESH | WFLG_CLOSEGADGET 
  1093.                      | WFLG_ACTIVATE | WFLG_RMBTRAP,
  1094.  
  1095.                    WA_Gadgets,     NULL,
  1096.                    WA_Title,       IWTitle,
  1097.                    WA_ScreenTitle, ScrTitle,
  1098.                    TAG_DONE ))
  1099.       )
  1100.       return( -4 );
  1101.  
  1102.    return( 0 );
  1103. }
  1104.  
  1105. PRIVATE void CloseIWindow( void )
  1106. {
  1107.    if (IWnd != NULL) 
  1108.       {
  1109.       CloseWindow( IWnd );
  1110.       IWnd = NULL;
  1111.       }
  1112.  
  1113.    return;
  1114. }
  1115.  
  1116. PRIVATE int ICloseWindow( void )
  1117. {
  1118.    CloseIWindow();
  1119.    return( (int) FALSE );
  1120. }
  1121.  
  1122. PRIVATE int HandleInfoIDCMP( void )
  1123. {
  1124.    struct IntuiMessage    *m;
  1125.    BOOL            running = TRUE;
  1126.  
  1127.    while (running == TRUE)
  1128.       {
  1129.       if ((m = (struct IntuiMessag *) GetMsg( IWnd->UserPort )) == NULL)
  1130.          {
  1131.          (void) Wait( 1L << IWnd->UserPort->mp_SigBit );
  1132.          continue;
  1133.          }
  1134.  
  1135.       CopyMem( (char *) m, (char *) &IMsg, 
  1136.                (long) sizeof( struct IntuiMessage )
  1137.              );
  1138.  
  1139.       ReplyMsg( (struct Message *) m );
  1140.  
  1141.       switch (IMsg.Class) 
  1142.          {
  1143.         case IDCMP_CLOSEWINDOW:
  1144.            running = ICloseWindow();
  1145.             break;
  1146.          }
  1147.       }
  1148.  
  1149.    return( running );
  1150. }
  1151.  
  1152.  
  1153. PRIVATE int HandleWindowInfo( void *structptr, int whichdisplay )
  1154. {
  1155.    int rval = 0;
  1156.    
  1157.    switch (whichdisplay)
  1158.       {
  1159.       case 0: // Screen data:
  1160.          rval = OpenIWindow( 16 );
  1161.          break;
  1162.  
  1163.       case 1: // Window data:
  1164.          rval = OpenIWindow( 25 );
  1165.          break;
  1166.  
  1167.       case 2: // Task data:
  1168.          rval = OpenIWindow( 13 );
  1169.          break;
  1170.  
  1171.       case 3: // Process data:
  1172.          rval = OpenIWindow( 28 );
  1173.          break;
  1174.       }
  1175.    
  1176.    if (rval < 0)
  1177.       {
  1178.       (void) Handle_Problem( "Couldn't open Information Window!", 
  1179.                              "Allocation Problem:", NULL 
  1180.                            );
  1181.       return( -1 );
  1182.       }
  1183.  
  1184.    DisplayStructure( structptr, whichdisplay );
  1185.       
  1186.    (void) HandleInfoIDCMP();
  1187.  
  1188.    return( 0 );
  1189. }
  1190.  
  1191. PRIVATE int CountWindows( struct Screen *scr )
  1192. {
  1193.    struct Window *w    = NULL;
  1194.    int            rval = 0;
  1195.    
  1196.    if (scr != NULL)
  1197.       w = scr->FirstWindow;
  1198.    else
  1199.       return( rval );
  1200.  
  1201.    while (w != NULL)
  1202.       {
  1203.       rval++;
  1204.       w = w->NextWindow;
  1205.       }
  1206.  
  1207.    return( rval );
  1208. }
  1209.  
  1210. PRIVATE int CountScreens( struct Screen *firstscreen )
  1211. {
  1212.    int rval = 0;
  1213.    
  1214.    while (firstscreen != NULL)
  1215.       {
  1216.       rval++;
  1217.       firstscreen = firstscreen->NextScreen;
  1218.       }
  1219.  
  1220.    return( rval );
  1221. }
  1222.  
  1223. PRIVATE int MakeScrWindowList( void )
  1224. {
  1225.    struct Screen *firstscr  = NULL;
  1226.    struct Screen *tempscr   = NULL;
  1227.    struct Screen *activescr = NULL;
  1228.    struct Window *activewnd = NULL;
  1229.    struct Screen *s         = NULL;
  1230.  
  1231.    ULONG          ilock       = 0L;
  1232.    int            i, numitems = 0;
  1233.    int            j, scrcount = 0;
  1234.  
  1235.    /* The following code works without the calls to LockIBase() &
  1236.    ** UnlockIBase() just fine.  They are here just in case:
  1237.    */
  1238.  
  1239.    ilock = LockIBase( 0 );
  1240.  
  1241.      firstscr  = IntuitionBase->FirstScreen;
  1242.      activescr = IntuitionBase->ActiveScreen;
  1243.      activewnd = IntuitionBase->ActiveWindow;
  1244.      scrcount  = CountScreens( firstscr );
  1245.      tempscr   = firstscr;     
  1246.      numitems  = scrcount;
  1247.           
  1248.      for (j = 0; j < scrcount; j++)
  1249.         {
  1250.         numitems += CountWindows( tempscr );
  1251.         tempscr   = tempscr->NextScreen;
  1252.         }
  1253.  
  1254.      s = firstscr;
  1255.      i = 1;
  1256.  
  1257.      do {
  1258.         struct Window *w = s->FirstWindow;
  1259.  
  1260.         if (s == activescr)
  1261.            sprintf( &NodeStrs[ i++ * 80 ], 
  1262.                     "%08LX+ %3u,%3u %4u,%4u %08LX 00000000 S: %-30.30s",
  1263.                     s, s->LeftEdge, s->TopEdge, s->Width, s->Height,
  1264.                     s->Flags, s->Title
  1265.                   );
  1266.         else
  1267.            sprintf( &NodeStrs[ i++ * 80 ], 
  1268.                     "%08LX  %3u,%3u %4u,%4u %08LX 00000000 S: %-30.30s",
  1269.                     s, s->LeftEdge, s->TopEdge, s->Width, s->Height,
  1270.                     s->Flags, s->Title
  1271.                   );
  1272.         do {
  1273.  
  1274.            if (w == activewnd)
  1275.               sprintf( &NodeStrs[ i++ * 80 ], 
  1276.                        "%08LX+ %3u,%3u %4u,%4u %08LX %08LX W: %-30.30s",
  1277.                        w, w->LeftEdge, w->TopEdge, w->Width, w->Height,
  1278.                        w->Flags, w->IDCMPFlags, w->Title
  1279.                      );
  1280.            else
  1281.               sprintf( &NodeStrs[ i++ * 80 ], 
  1282.                        "%08LX  %3u,%3u %4u,%4u %08LX %08LX W: %-30.30s",
  1283.                        w, w->LeftEdge, w->TopEdge, w->Width, w->Height,
  1284.                        w->Flags, w->IDCMPFlags, w->Title
  1285.                      );
  1286.            
  1287.            w = w->NextWindow;
  1288.  
  1289.            } while ((w != NULL) && (i <= MAXNODE));
  1290.  
  1291.         s = s->NextScreen;
  1292.  
  1293.         } while ((s != NULL) && (i <= MAXNODE));
  1294.         
  1295.    UnlockIBase( ilock );
  1296.  
  1297.    return( numitems );
  1298. }
  1299.  
  1300. PRIVATE BOOL IsScreen( ULONG address )
  1301. {
  1302.    struct Screen *scr   = NULL;
  1303.  
  1304.    ULONG          ilock = 0L;
  1305.    BOOL           rval  = FALSE;
  1306.     
  1307.    ilock = LockIBase( 0 );
  1308.  
  1309.      scr  = IntuitionBase->FirstScreen;
  1310.  
  1311.      while (scr != NULL)
  1312.         {
  1313.         if (scr == (struct Screen *) address)
  1314.            {
  1315.            rval = TRUE;
  1316.            break;
  1317.            }
  1318.  
  1319.         scr = scr->NextScreen;
  1320.         }
  1321.      
  1322.    UnlockIBase( ilock );
  1323.  
  1324.    return( rval );
  1325. }
  1326.  
  1327. PRIVATE struct Window *selected_w = NULL;
  1328. PRIVATE struct Screen *selected_s = NULL;
  1329.  
  1330. PRIVATE int SLVClicked( int itemnum )
  1331. {
  1332.    ULONG addr = 0L;
  1333.    
  1334. //#  ifdef DEBUG
  1335. //   fprintf( stderr, "%-80.80s\n", ScrNodes[ itemnum ].ln_Name );
  1336. //#  endif
  1337.  
  1338.    if (itemnum == 0)   
  1339.       {
  1340.       GT_SetGadgetAttrs( ScrGadgets[ ScrMore ], Wnd, NULL,
  1341.                          GA_Disabled, TRUE, TAG_DONE 
  1342.                        );
  1343.  
  1344.       GT_SetGadgetAttrs( ScrGadgets[ ScrClose ], Wnd, NULL,
  1345.                          GA_Disabled, TRUE, TAG_DONE 
  1346.                        );
  1347.  
  1348.       GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1349.                          GTTX_Text, NULL,
  1350.                          TAG_DONE
  1351.                        );
  1352.  
  1353.       return( (int) TRUE );
  1354.       }
  1355.    else
  1356.       {
  1357.       GT_SetGadgetAttrs( ScrGadgets[ ScrMore ], Wnd, NULL,
  1358.                          GA_Disabled, FALSE, TAG_DONE 
  1359.                        );
  1360.  
  1361.       GT_SetGadgetAttrs( ScrGadgets[ ScrClose ], Wnd, NULL,
  1362.                          GA_Disabled, FALSE, TAG_DONE 
  1363.                        );
  1364.  
  1365.       GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1366.                          GTTX_Text, ScrNodes[ itemnum ].ln_Name, 
  1367.                          TAG_DONE
  1368.                        );
  1369.  
  1370.       // Now get address from the item & determine if it's a screen or
  1371.       // window.  Then set selected_s or selected_w.
  1372.       (void) stch_l( ScrNodes[ itemnum ].ln_Name, (long *) &addr );
  1373.       
  1374.       if (IsScreen( addr ) == TRUE)
  1375.          {
  1376.          selected_s = (struct Screen *) addr;
  1377.          selected_w = NULL;
  1378.          }
  1379.       else
  1380.          {
  1381.          selected_s = NULL;
  1382.          selected_w = (struct Window *) addr;
  1383.          }
  1384.       }
  1385.  
  1386.    return( (int) TRUE );
  1387. }
  1388.  
  1389.  
  1390. PRIVATE int UpdateClicked( int dummy )
  1391. {
  1392.    int i;
  1393.    
  1394.    GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1395.                       GTTX_Text, NULL,
  1396.                       TAG_DONE
  1397.                     );
  1398.  
  1399.    for (i = 1; i <= MAXNODE; i++)
  1400.        NodeStrs[ i * 80 ] = '\0'; // Kill old ListView strings.
  1401.  
  1402.    (void) MakeScrWindowList();    // Remake ListView strings.
  1403.  
  1404.    GT_RefreshWindow( Wnd, NULL );
  1405.  
  1406.    return( (int) TRUE );
  1407. }
  1408.  
  1409. PRIVATE int MoreClicked( int dummy )
  1410. {
  1411.    if (selected_s != NULL)
  1412.       {
  1413.       // Show all of the Screen Information:
  1414.       (void) HandleWindowInfo( (void *) selected_s, 0 );
  1415.       }
  1416.    else if (selected_w != NULL)
  1417.       {
  1418.       // Show all of the Window Information:
  1419.       (void) HandleWindowInfo( (void *) selected_w, 1 );
  1420.       }
  1421.    else
  1422.       {
  1423.       // Some sort of error:
  1424.       (void) Handle_Problem( "MoreClicked() internal error condition!",
  1425.                              "SysScreens() Internal ERROR:", NULL
  1426.                            );
  1427.       }   
  1428.  
  1429.    return( (int) TRUE );
  1430. }
  1431.  
  1432. PRIVATE BOOL CheckWindow( struct Window *findwin )
  1433. {
  1434.   struct Window *win;
  1435.   struct Screen *scr;
  1436.   ULONG          lock = 0L;
  1437.   BOOL           ret  = FALSE;
  1438.  
  1439.   lock = LockIBase( NULL );
  1440.  
  1441.   scr = IntuitionBase->FirstScreen;
  1442.   
  1443.   while ((scr != NULL) && (ret == FALSE))
  1444.      {
  1445.      win = scr->FirstWindow;
  1446.      
  1447.      while (win != NULL)
  1448.         {
  1449.         if (win == findwin)
  1450.            {
  1451.            ret = TRUE;
  1452.            break;
  1453.            }
  1454.  
  1455.         win = win->NextWindow;
  1456.         }
  1457.  
  1458.      scr = scr->NextScreen;
  1459.      }
  1460.  
  1461.   UnlockIBase( lock );
  1462.  
  1463.   return( ret );
  1464. }
  1465.  
  1466. PRIVATE BOOL CheckScreen( struct Screen *findscr )
  1467. {
  1468.   struct Screen *scr;
  1469.   ULONG          lock = 0L;
  1470.   BOOL           ret  = FALSE;
  1471.  
  1472.   lock = LockIBase( NULL );
  1473.  
  1474.   scr = IntuitionBase->FirstScreen;
  1475.  
  1476.   while (scr != NULL)
  1477.      { 
  1478.      if (scr == findscr)
  1479.         {
  1480.         ret = TRUE;
  1481.         break;
  1482.         } 
  1483.  
  1484.      scr = scr->NextScreen;
  1485.      }
  1486.  
  1487.   UnlockIBase( lock );
  1488.  
  1489.   return( ret );
  1490. }
  1491.  
  1492. PUBLIC void CloseTheWindow( struct Window *wind )
  1493. {
  1494.    if (CheckWindow( wind ) == TRUE)
  1495.       {
  1496.       if ((wind->ReqCount != 0) && wind->FirstRequest)
  1497.          {
  1498.          while (wind->ReqCount != 0)
  1499.             EndRequest( wind->FirstRequest, wind );
  1500.          }
  1501.  
  1502.       if (wind->DMRequest != NULL)
  1503.          ClearDMRequest( wind );
  1504.  
  1505.       if (wind->Pointer != NULL)
  1506.          ClearPointer( wind );
  1507.  
  1508.       if (wind->MenuStrip != NULL)
  1509.          ClearMenuStrip( wind );
  1510.  
  1511.       CloseWindow( wind );
  1512.       }
  1513.  
  1514.    return;
  1515. }
  1516.  
  1517. PUBLIC void CloseTheScreen( struct Screen *scr )
  1518. {
  1519.   struct Window *win = scr->FirstWindow, *markwin;
  1520.  
  1521.   if (CheckScreen( scr ) == TRUE)
  1522.      {
  1523.      while (win != NULL)
  1524.         {
  1525.         markwin = win->NextWindow;
  1526.         CloseTheWindow( win );
  1527.         win     = markwin;
  1528.     }
  1529.  
  1530.      CloseScreen( scr );
  1531.      }
  1532.  
  1533.    return;
  1534. }
  1535.  
  1536. PRIVATE int CloseClicked( int dummy )
  1537. {
  1538.    // Check selected_s & selected_w for a non-NULL value
  1539.    char ErrMsg[256];
  1540.    
  1541.    if (selected_s != NULL)
  1542.       {
  1543.       sprintf( ErrMsg, "Are you SURE you want to close %08lx?", 
  1544.                         selected_s
  1545.              );
  1546.  
  1547.       if (SanityCheck( ErrMsg ) == TRUE)
  1548.          {
  1549.          if (selected_s == Scr)
  1550.             {
  1551.             (void) Handle_Problem( "Screen %08lx CANNOT be closed!",
  1552.                                    "User ERROR:", (int *) &Scr
  1553.                                  );
  1554.  
  1555.             return( (int) TRUE );
  1556.             }
  1557.  
  1558.          CloseTheScreen( selected_s );
  1559.  
  1560.          (void) MakeScrWindowList();
  1561.          GT_RefreshWindow( Wnd, NULL );
  1562.          }
  1563.       else
  1564.          return( (int) TRUE );
  1565.       }
  1566.    else if (selected_w != NULL)
  1567.       {
  1568.       sprintf( ErrMsg, "Are you SURE you want to close %08lx?", 
  1569.                         selected_w
  1570.              );
  1571.  
  1572.       if (SanityCheck( ErrMsg ) == TRUE)
  1573.          {
  1574.          if (selected_w == Wnd)
  1575.             {
  1576.             (void) Handle_Problem( "Window %08lx CANNOT be closed!",
  1577.                                    "User ERROR:", (int *) &Wnd
  1578.                                  );
  1579.  
  1580.             return( (int) TRUE );
  1581.             }
  1582.  
  1583.          CloseTheWindow( selected_w );
  1584.  
  1585.          (void) MakeScrWindowList();
  1586.          GT_RefreshWindow( Wnd, NULL );
  1587.          }
  1588.       else
  1589.          return( (int) TRUE );
  1590.       }
  1591.    else
  1592.       {
  1593.       // Some sort of error:
  1594.       (void) Handle_Problem( "CloseClicked() internal error condition!",
  1595.                              "SysScreens() Internal ERROR:", NULL
  1596.                            );
  1597.  
  1598.       return( (int) TRUE );
  1599.       }   
  1600.  
  1601.    return( (int) TRUE );
  1602. }
  1603.  
  1604. PRIVATE void CloseScrWindow( void )
  1605. {
  1606.    if (Wnd)
  1607.       {
  1608.       CloseWindow( Wnd );
  1609.       Wnd = NULL;
  1610.       }
  1611.  
  1612.    if (GList)
  1613.       {
  1614.       FreeGadgets( GList );
  1615.       GList = NULL;
  1616.       }
  1617.  
  1618.    if (TFont)
  1619.       {
  1620.       CloseFont( TFont );
  1621.       TFont = NULL;
  1622.       }
  1623.  
  1624.    return;
  1625. }
  1626.  
  1627. PRIVATE int ScrCloseWindow( void )
  1628. {
  1629.    CloseScrWindow();
  1630.    return( (int) FALSE );
  1631. }
  1632.  
  1633. PRIVATE int CancelClicked( int dummy )
  1634. {
  1635.    return( ScrCloseWindow() );
  1636. }
  1637.  
  1638. PRIVATE int OpenScrWindow( void )
  1639. {
  1640.    struct NewGadget  ng;
  1641.    struct Gadget    *g;
  1642.    UWORD             lc, tc;
  1643.    UWORD             wleft = WLeft, wtop = WTop, ww, wh;
  1644.  
  1645.    ComputeFont( Scr, Font, &CFont, WWidth, WHeight );
  1646.  
  1647.    ww = ComputeX( CFont.FontX, WWidth );
  1648.    wh = ComputeY( CFont.FontY, WHeight );
  1649.  
  1650.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width)
  1651.       wleft = Scr->Width - ww;
  1652.  
  1653.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height)
  1654.       wtop = Scr->Height - wh;
  1655.  
  1656.    if ( !(TFont = OpenDiskFont( Font )))
  1657.       return( -5 );
  1658.  
  1659.    if ( !(g = CreateContext( &GList )))
  1660.       return( -1 );
  1661.  
  1662.    for (lc = 0, tc = 0; lc < SCR_CNT; lc++)
  1663.       {
  1664.       CopyMem( (char *) &ScrNGad[ lc ], (char *) &ng, 
  1665.                (long) sizeof( struct NewGadget )
  1666.              );
  1667.  
  1668.       ng.ng_VisualInfo = VisualInfo;
  1669.       ng.ng_TextAttr   = Font;
  1670.       ng.ng_LeftEdge   = CFont.OffX + ComputeX( CFont.FontX, 
  1671.                                                 ng.ng_LeftEdge 
  1672.                                               );
  1673.  
  1674.       ng.ng_TopEdge    = CFont.OffY + ComputeY( CFont.FontY, 
  1675.                                                 ng.ng_TopEdge 
  1676.                                               );
  1677.  
  1678.       ng.ng_Width      = ComputeX( CFont.FontX, ng.ng_Width  );
  1679.       ng.ng_Height     = ComputeY( CFont.FontY, ng.ng_Height );
  1680.  
  1681.       ScrGadgets[lc] = g = CreateGadgetA( (ULONG) ScrGTypes[lc], 
  1682.                             g, 
  1683.                             &ng, 
  1684.                             (struct TagItem *) &ScrGTags[tc] );
  1685.  
  1686.       while (ScrGTags[tc])
  1687.          tc += 2;
  1688.  
  1689.       tc++;
  1690.       if (NOT g)
  1691.          return( -2 );
  1692.       }
  1693.  
  1694.    if ( !(Wnd = OpenWindowTags( NULL,
  1695.  
  1696.                  WA_Left,        wleft,
  1697.                  WA_Top,         wtop,
  1698.                  WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  1699.                  WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  1700.                  WA_IDCMP,       LISTVIEWIDCMP | BUTTONIDCMP 
  1701.                    | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW,
  1702.  
  1703.                  WA_Flags,       WFLG_DRAGBAR | WFLG_DEPTHGADGET 
  1704.                    | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH | WFLG_ACTIVATE 
  1705.                    | WFLG_RMBTRAP,
  1706.                  
  1707.                  WA_Gadgets,     GList,
  1708.                  WA_Title,       WTitle,
  1709.                  WA_ScreenTitle, ScrTitle,
  1710.                  TAG_DONE ))
  1711.       )
  1712.       return( -4 );
  1713.  
  1714.    GT_RefreshWindow( Wnd, NULL );
  1715.  
  1716.    return( 0 );
  1717. }
  1718.  
  1719. PRIVATE int HandleScrIDCMP( void )
  1720. {
  1721.    struct IntuiMessage *m;
  1722.    int                 (*func)( int );
  1723.    BOOL                running = TRUE;
  1724.  
  1725.    while (running == TRUE)
  1726.       {
  1727.       if ((m = GT_GetIMsg( Wnd->UserPort )) == NULL)
  1728.          {
  1729.          (void) Wait( 1L << Wnd->UserPort->mp_SigBit );
  1730.          continue;
  1731.          }
  1732.  
  1733.       CopyMem( (char *) m, (char *) &IMsg, 
  1734.                (long) sizeof( struct IntuiMessage ) 
  1735.              );
  1736.  
  1737.       GT_ReplyIMsg( m );
  1738.  
  1739.       switch (IMsg.Class)
  1740.          {
  1741.          case IDCMP_REFRESHWINDOW:
  1742.             GT_BeginRefresh( Wnd );
  1743.             GT_EndRefresh( Wnd, TRUE );
  1744.             break;
  1745.  
  1746.          case IDCMP_CLOSEWINDOW:
  1747.             running = ScrCloseWindow();
  1748.             break;
  1749.  
  1750.          case IDCMP_GADGETUP:
  1751.             func    = (void *) ((struct Gadget *) IMsg.IAddress)->UserData;
  1752.             running = func( (int) IMsg.Code );
  1753.             break;
  1754.          }
  1755.       }
  1756.  
  1757.    return( running );
  1758. }
  1759.  
  1760. PUBLIC int HandleScreenLV( void )
  1761. {
  1762.    int i = 0;
  1763.    
  1764.    ScrNode.ln_Succ = (struct Node *) ScrList.mlh_Tail;
  1765.    ScrNode.ln_Pred = (struct Node *) ScrList.mlh_Head;
  1766.    ScrNode.ln_Type = 0;
  1767.    ScrNode.ln_Pri  = 100;
  1768.    ScrNode.ln_Name = "Address     Pos     Size    Flags    IDCMP       Title";
  1769.  
  1770.    ScrNodes[0]     = ScrNode;
  1771.        
  1772.    if (SetupSystemList( &OpenScrWindow ) < 0)
  1773.       {
  1774.       (void) Handle_Problem( "Couldn't open a System ListViewer!", 
  1775.                              "Allocation Problem:", NULL 
  1776.                            );
  1777.       return( -1 );
  1778.       }
  1779.  
  1780.    SetNotifyWindow( Wnd ); // For Handle_Problem().
  1781.   
  1782.    // ScrNodes[0] is already set up:
  1783.  
  1784.    for (i = 1; i <= MAXNODE; i++)
  1785.        {
  1786.        ScrNodes[i].ln_Name = &NodeStrs[ i * 80 ];
  1787.        ScrNodes[i].ln_Pri  = MAXNODE - i;
  1788.        }     
  1789.  
  1790.    NewList( (struct List *) &ScrList );
  1791.  
  1792.    for (i = 0; i < MAXNODE; i++)
  1793.       Enqueue( (struct List *) &ScrList, &ScrNodes[i] );
  1794.  
  1795.    (void) MakeScrWindowList();
  1796.  
  1797.    ModifyListView( ScrGadgets[ ScrLV ], Wnd, 
  1798.                    (struct List *) &ScrList, NULL
  1799.                  );
  1800.  
  1801.    GT_RefreshWindow( Wnd, NULL );
  1802.  
  1803.    (void) HandleScrIDCMP();
  1804.    
  1805.    ShutdownSystemList();
  1806.    return( 0 );
  1807. }
  1808.  
  1809. #ifdef DEBUG
  1810.  
  1811. PUBLIC int main( void )
  1812. {
  1813.    return( HandleScreenLV() );
  1814. }
  1815.  
  1816. #endif
  1817.  
  1818. /* --------------------- END of SysScreens.c file! -------------------- */
  1819.